function deepClone(target: any) {
    const map = new WeakMap()
    
    function isObject(target: any) {
        return (typeof target === 'object' && target ) || typeof target === 'function'
    }

    function clone(data: any) {
        if (!isObject(data)) {
            return data
        }
        if ([Date, RegExp].includes(data.constructor)) {
            return new data.constructor(data)
        }
        if (typeof data === 'function') {
            return new Function('return ' + data.toString())()
        }
        const exist = map.get(data)
        if (exist) {
            return exist
        }
        if (data instanceof Map) {
            const result = new Map()
            map.set(data, result)
            data.forEach((val, key) => {
                if (isObject(val)) {
                    result.set(key, clone(val))
                } else {
                    result.set(key, val)
                }
            })
            return result
        }
        if (data instanceof Set) {
            const result = new Set()
            map.set(data, result)
            data.forEach(val => {
                if (isObject(val)) {
                    result.add(clone(val))
                } else {
                    result.add(val)
                }
            })
            return result
        }
        const keys = Reflect.ownKeys(data)
        const allDesc = Object.getOwnPropertyDescriptors(data)
        const result = Object.create(Object.getPrototypeOf(data), allDesc)
        map.set(data, result)
        keys.forEach(key => {
            const val = data[key]
            if (isObject(val)) {
                result[key] = clone(val)
            } else {
                result[key] = val
            }
        })
        return result
    }

    return clone(target)
}
function sampleArrayByRate(array: any, sampleRate: any = 2) {
    array = isTypedArray(array) ? array : toTypedArray(array)
    const length = array.length
    const step = Math.max(1, Math.floor(length / sampleRate)) // 计算步长
    const sampledArray = new Array(sampleRate) // 创建采样数组
    
    for (let i = 0; i < sampleRate; i++) {
        const index = i * step // 计算采样下标
        sampledArray[i] = array[index] // 直接访问并存储元素
    }
    
    return sampledArray
}
function sampleArrayByRateForCharts(obj: any, sampleRate: any = 0.5) {
    // 确保输入数组是数值类型数组
    const imag = obj.imag ? (isTypedArray(obj.imag) ? obj.imag : toTypedArray(obj.imag)) : (isTypedArray(obj.y.doubleArray) ? obj.imag : toTypedArray(obj.y.doubleArray))
    const real = obj.real ? (isTypedArray(obj.real) ? obj.real : toTypedArray(obj.real)) : (isTypedArray(obj.x.doubleArray) ? obj.real : toTypedArray(obj.x.doubleArray))

    const length = imag.length
    const step = Math.max(1, Math.floor(length * sampleRate)) // 计算步长
    const sampledArray = new Array(step) // 创建采样数组
    
    for (let i = 0; i < step; i++) {
        const index = Math.trunc(i / sampleRate) // 计算采样下标
        if (index < length) {
            sampledArray[i] = [real[index], imag[index]] // 直接访问并存储元素
        }
    }
    
    return sampledArray
}
  // 辅助函数：检查输入是否为TypedArray
function isTypedArray(array: any) {
    return array instanceof Int8Array ||
        array instanceof Uint8Array ||
        array instanceof Uint8ClampedArray ||
        array instanceof Int16Array ||
        array instanceof Uint16Array ||
        array instanceof Int32Array ||
        array instanceof Uint32Array ||
        array instanceof Float32Array ||
        array instanceof Float64Array
}
    
// 辅助函数：将常规数组转换为Float32Array
function toTypedArray(array: any) {
    return new Float32Array(array)
}

function convertToNestedObject(arr: any) {
    // 递归函数，用于构建嵌套对象  
    function buildNestedObject(arr: any, index = 0) {
        if (index >= arr.length) {
            return null // 递归结束条件
        }
        
        const currentLabel = arr[index]
        const nextChildren: any = buildNestedObject(arr, index + 1) // 递归调用以获取下一个级别的子元素
        
        const tree: any = nextChildren ? {
            label: currentLabel,
            value: currentLabel,
            children: [nextChildren] // 如果存在子元素，则将其包装在数组中
        } : {
            label: currentLabel,
            value: currentLabel,
        }
        return tree
    }
    
    return buildNestedObject(arr) // 从数组的第一个元素开始构建嵌套对象
}
function convertToScientificIfManyZeros(num: any) {
    
    const numStr = String(num); // 将数字转换为字符串以便检查零的数量  
    const zeroRegex = /0{3,}/; // 正则表达式，匹配3个或更多的连续零  
      
    if (zeroRegex.test(numStr)) {  
      // 如果找到3个或更多的连续零，使用toExponential()转换为科学计数法  
      // 这里我们可以选择小数点后的位数，比如使用默认的或者指定为某个值  
        return num.toExponential(); // 默认情况下，小数点后保留尽可能多的有效数字  
    } else {  
      // 否则，返回原始数字（未转换为科学计数法）  
        return num;
    }
}
function getType(value: any) {  
    const type = typeof value;  
    
    if (type === 'object') {  
      if (value === null) {  
        return 'null';  
      } else if (Array.isArray(value)) {  
        return 'array';  
      } else if (value instanceof Date) {  
        return 'date';  
      } else if (value instanceof RegExp) {  
        return 'regexp';  
      } else if (typeof value.constructor === 'function') {  
        const constructorName = value.constructor.name;  
        if (constructorName !== 'Object') {  
          return constructorName.toLowerCase(); // 用户自定义类型或内置对象的其他类型（如Map, Set等）  
        }  
      }  
      // 对于普通的对象 {}，返回 'object'  
      return 'object';  
    } else if (type === 'function') {  
      // 对于函数，可以进一步区分是否是箭头函数、普通函数等，但这里简化为 'function'  
      return 'function';  
    }  
    
    // 对于原始类型（除了object和function），直接返回typeof的结果  
    return type;  
}
function fsToS(value: any) {
    if (typeof value === 'string') value = Number.parseFloat(value)
    return value / 1e15
}
function sToFs(value: any) {
    if (typeof value === 'string') value = Number.parseFloat(value)
    return value * 1e15
}
function umToM(value: any) {  
    if (typeof value === 'string') value = Number.parseFloat(value)
    return value / 1000000
}
function mToUm(value: any) {  
    if (typeof value === 'string') value = Number.parseFloat(value)
    return value * 1000000
}
export { deepClone, sampleArrayByRate, sampleArrayByRateForCharts, convertToNestedObject, convertToScientificIfManyZeros, getType, fsToS, sToFs, umToM, mToUm }